home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / devel / lang / ada / adaed-1.11 / adaed-1 / Adaed-1.11.0a / chapprots.h < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-07  |  7.3 KB  |  281 lines
  1. /*
  2.  * Copyright (C) 1985-1992  New York University
  3.  * 
  4.  * This file is part of the Ada/Ed-C system.  See the Ada/Ed README file for
  5.  * warranty (none) and distribution info and also the GNU General Public
  6.  * License for more details.
  7.  
  8.  */
  9.  
  10. /* Only 12b used by adagen*/
  11. #ifndef GEN
  12.  
  13. /* 0a */
  14. void init_sem();
  15. int in_op_designators(char *);
  16.  
  17. /* 0b */
  18. void adasem(Node);
  19. void sem_list(Node);
  20.  
  21. /* 2 */
  22. void process_pragma(Node);
  23.  
  24. /* 3a */
  25.  
  26. void obj_decl(Node);
  27. void const_decl(Node);
  28. Symbol check_init(Node, Node);
  29. int is_deferred_constant(Node);
  30. void number_decl(Node);
  31. void type_decl(Node);
  32. Symbol find_type_name(Node);
  33. void check_delayed_type(Node, Symbol);
  34. void subtype_decl(Node);
  35. Symbol make_subtype(Node);
  36. int is_derived_subprogram(Symbol);
  37.  
  38. /* 3b */
  39. Tuple apply_range(Node);
  40. void array_typedef(Node);
  41. void new_array_type(Symbol, Node);
  42. void new_constrained_array(Symbol, Node);
  43. Symbol anonymous_array(Node);
  44. Symbol constrain_array(Symbol, Node);
  45. Symbol make_index(Node);
  46. void record_decl(Symbol, Node, Node);
  47. void process_discr(Symbol, Node);
  48. void discr_redecl(Symbol, Node);
  49. int same_expn(Node exp1, Node exp2);
  50. void conformance_error(Node);
  51. void comp_decl(Node);
  52. Symbol constrain_record(Symbol, Node);
  53. int check_discriminant(Node);
  54. void variant_decl(Node);
  55. void incomplete_decl(Node);
  56. void check_incomplete(Symbol);
  57. void declarative_part(Node);
  58. Symbol promote_subtype(Symbol);
  59. Tuple subtype_expr(Symbol);
  60. int is_character_type(Symbol);
  61. int is_discrete_type(Symbol);
  62. int is_numeric(Symbol);
  63. int is_incomplete_type(Symbol);
  64. int is_unconstrained(Symbol);
  65. Symbol base_type(Symbol);
  66. Symbol named_type(char *);
  67. Symbol anonymous_type();
  68. Symbol named_atom(char *);
  69. int is_static_expr(Node);
  70.  
  71. /* 4a */
  72. int in_type_classes(Symbol);
  73. void check_type_i(Node);
  74. void check_type_r(Node);
  75. void check_type_d(Node);
  76. void check_type_u(Node);
  77. void check_type(Symbol, Node);
  78. void apply_constraint(Node, Symbol);
  79. int in_priv_types(Symbol);
  80. void resolve1(Node);
  81. void resolv_attr(Node);
  82. void resolve2(Node, Symbol);
  83.  
  84. /* 4b */
  85. void result_types(Node);
  86. void disambiguate(Node, Symbol);
  87. void remove_conversions(Node);
  88. Tuple valid_arith_types(Symbol, Tuple);
  89. Symbol intersect_types(Symbol t1, Symbol t2);
  90. void complete_op_expr(Node, Symbol);
  91. void specialize(Node, Symbol);
  92. void complete_arg_list(Tuple, Node);
  93.  
  94. /* 4c */
  95. int can_constrain(Symbol);
  96. Set valid_array_expn(Node);
  97. Symbol complete_array_expn(Node, Symbol);
  98. void valid_selected_expn(Node);
  99. Symbol complete_selected_expn(Node, Symbol);
  100. void complete_aggregate(Symbol, Node);
  101. void complete_string_literal(Node, Symbol);
  102. void complete_r_aggregate(Symbol, Node);
  103. Tuple build_comp_names(Node);
  104. void valid_task_name(Node);
  105. void complete_task_name(Node task1, Symbol);
  106. void res2_check(Node expn2, Symbol);
  107. Symbol attribute_type(int, Symbol, Node arg1, Node arg2);
  108. int compatible_types(Symbol, Symbol);
  109. void type_error(Set, Symbol, int, Node);
  110. void premature_access(Symbol, Node);
  111. void pass1_error(char *msg1, char *, Node);
  112. char *full_type_name(Symbol);
  113. int is_type_node(Node);
  114.  
  115. /* 5 */
  116. Symbol slice_type(Node,int);
  117. void new_symbol(Symbol, int, Symbol, Tuple, Symbol);
  118. Symbol get_type(Node);
  119. void assign_statement(Node);
  120. int is_variable(Node);
  121. void statement_list(Node);
  122. void if_statement(Node);
  123. void case_statement(Node);
  124. void process_case(Symbol, Node);
  125. int is_static_subtype(Symbol);
  126. void new_block(Node);
  127. void loop_statement(Node);
  128. Symbol iter_var(Node);
  129. void exit_statement(Node);
  130. void return_statement(Node);
  131. void label_decl(Node);
  132. void lab_init();
  133. void lab_end();
  134. void goto_statement(Node);
  135.  
  136. /* 6 */
  137. void subprog_decl(Node);
  138. void check_spec(Node);
  139. void check_new_op(Node, Tuple, Symbol);
  140. Tuple get_formals(Node, char *);
  141. void subprog_body(Node);
  142. void process_subprog_body(Node, Symbol);
  143. Node new_not_equals(Symbol, Symbol);
  144. Tuple process_formals(Symbol, Tuple,int);
  145. void reprocess_formals(Symbol, Node);
  146. void normalize(Symbol, Node);
  147. int conform(Node exp1, Node exp2);
  148. void call_statement(Node);
  149. Symbol chain_overloads(char *, int, Symbol, Tuple, Symbol, Node);
  150. int can_overload(Symbol);
  151. int same_signature(Symbol sub1, Symbol sub2);
  152. int same_sig_spec(Symbol, Tuple);
  153. int same_type(Symbol type1, Symbol type2);
  154.  
  155. /* 7 */
  156. void package_specification(Node);
  157. void new_package(Node, int);
  158. void package_declarations(Node, Node);
  159. void module_body_id(int, Node);
  160. void module_body(int, Node);
  161. void private_decl(Node);
  162. void check_fully_declared(Symbol);
  163. void check_fully_declared2(Symbol);
  164. int is_private(Symbol);
  165. int is_limited_type(Symbol);
  166. void check_out_parameters(Tuple);
  167. int in_private_part(Symbol);
  168. int private_kind(Symbol);
  169. int is_fully_private(Symbol);
  170. void check_priv_decl(int, Symbol);
  171. Symbol private_ancestor(Symbol);
  172. void end_specs(Symbol);
  173. void check_incomplete_decls(Symbol, Node);
  174. Symbol get_specs(char *);
  175.  
  176. /* 8 */
  177. void find_old(Node);
  178. Symbol find_type(Node);
  179. void check_old(Node);
  180. Set find_agg_types();
  181. Set find_access_types();
  182. Symbol find_new(char *);
  183. void check_void(char *);
  184. void new_agg_or_access_acc(Symbol);
  185. void new_agg_or_access_agg(Symbol);
  186. char *original_name(Symbol);
  187. void rename_ex(Node);
  188. void rename_pack(Node);
  189. void rename_subprogram(Node);
  190. Tuple find_renamed_entity(int, Tuple, Symbol, Node);
  191. void rename_object(Node);
  192. void newscope(Symbol);
  193. void popscope();
  194. void newmod(char *);
  195. void use_clause(Node);
  196.  
  197. /* 9 */
  198. void task_spec(Node);
  199. void accept_statement(Node);
  200. void entry_decl(Node);
  201. void entry_family_decl(Node);
  202. void entry_call(Node);
  203. void check_entry_call(Node);
  204. void find_entry_name(Node);
  205. void terminate_statement(Node);
  206. void abort_statement(Node);
  207.  
  208. /* 10 */
  209. void new_compunit(char *, Node);
  210. void compunit(Node);
  211. #ifdef SAVE_TRACE
  212. void save_trace(char *, int, Node);
  213. #endif
  214. void save_trace_init();
  215. Tuple unit_symbtab(Symbol, char);
  216. void save_subprog_info(Symbol);
  217. void save_spec_info(Symbol, Tuple);
  218. void save_body_info(Symbol);
  219. void stub_head(int, Node);
  220. void save_stub(Node);
  221.  
  222. /* 11 */
  223. void except_decl(Node);
  224. void exception_part(Node);
  225. void exception_handler(Node);
  226. void raise_statement(Node);
  227.  
  228. /* 12a */
  229. void generic_subprog_spec(Node);
  230. void generic_subprog_body(Symbol, Node);
  231. void generic_pack_spec(Node);
  232. void generic_obj_decl(Node);
  233. void generic_type_decl(Node);
  234. void generic_priv_decl(Node);
  235. void check_generic_usage(Symbol);
  236. void generic_subp_decl(Node);
  237. void subprog_instance(Node);
  238. void package_instance(Node);
  239.  
  240. #endif
  241. /* 12b */
  242. void instantiate_subprog_tree(Node, Symbolmap);
  243. void instantiate_pack_tree(Node, Symbolmap, Tuple);
  244. Tuple instantiate_symbtab(Symbol, Symbol, Symbolmap);
  245. void update_symbtab_nodes(Symbolmap, Tuple);
  246. Private_declarations update_private_decls(Symbol, Symbolmap);
  247. Node instantiate_tree(Node, Symbolmap);
  248. Symbol replace(Symbol, Symbolmap);
  249. Symbolmap symbolmap_new();
  250. Symbol symbolmap_get(Symbolmap, Symbol);
  251. void symbolmap_put(Symbolmap, Symbol, Symbol);
  252. Nodemap nodemap_new();
  253. #ifndef GEN
  254.  
  255. /* 12c */
  256. Tuple instantiate_generics(Tuple, Node);
  257. Tuple check_nat_type(Node);
  258. void desig_to_op(Node);
  259. int is_discriminant_dependent(Node);
  260. void linear(Symbol);
  261. Symbol anon_proc_instance(Symbol, Tuple, Symbol);
  262. void is_identifier();
  263. void is_tuple();
  264.  
  265. /* 13 */
  266. void length_clause(Node);
  267. void enum_rep_clause(Node);
  268. void rec_rep_clause(Node);
  269. void initialize_representation_info(Symbol, int);
  270. void choose_representation(Symbol);
  271. void inherit_representation_info(Symbol, Symbol);
  272. int     already_forced(Symbol);
  273. void not_chosen_put(Symbol, Symbol);
  274. Node size_attribute(Node);
  275. Node storage_size_attribute(Node);
  276. void force_representation(Symbol);
  277. void force_all_types();
  278. /* 14 */
  279. void check_range_attribute(Node);
  280. #endif
  281.